home *** CD-ROM | disk | FTP | other *** search
/ Linux Cubed Series 2: Applications / Linux Cubed Series 2 - Applications.iso / hamradio / tnos-2.000 / tnos-2 / sql.c < prev    next >
C/C++ Source or Header  |  1996-06-23  |  6KB  |  354 lines
  1. #include "global.h"
  2. #include "commands.h"
  3. #include "socket.h"
  4. #include "sql.h"
  5.  
  6.  
  7. #if !defined(_lint) && !defined(MSDOS)
  8. static char rcsid[] OPTIONAL = "$Id: sql.c,v 1.7 1996/06/24 02:54:26 root Exp root $";
  9. #endif
  10.  
  11. #ifdef SQL
  12.  
  13. static char *SQL_HOST;
  14. static char *SQL_DATABASE;
  15. static void separatorline __ARGS((m_result *result));
  16. static int SQL_LIMIT = 1;
  17.  
  18. #define SQLRETRIES 20
  19.  
  20.  
  21. static int dosqlquery __ARGS((int argc,char *argv[],void *p));
  22. static int dosqluserquery __ARGS((int argc,char *argv[],void *p));
  23. static int dosqlhost __ARGS((int argc,char *argv[],void *p));
  24. static int dosqllimit __ARGS((int argc,char *argv[],void *p));
  25. static int dosqldatabase __ARGS((int argc,char *argv[],void *p));
  26.  
  27. /* sql subcommand table */
  28. static struct cmds SOUNDtab[] = {
  29.     { "database",        dosqldatabase,        0, 0, NULLCHAR },
  30.     { "host",        dosqlhost,        0, 0, NULLCHAR },
  31.     { "limitusers",        dosqllimit,        0, 0, NULLCHAR },
  32.     { "query",        dosqlquery,        0, 2, "sql query \"query string\"" },
  33.     { "userquery",        dosqluserquery,        0, 2, "sql userquery \"select query string\"" },
  34.     { NULLCHAR,        NULL,            0, 0, NULLCHAR }
  35. };
  36.  
  37.  
  38. int
  39. dosql(argc,argv,p)
  40. int argc;
  41. char *argv[];
  42. void *p;
  43. {
  44.     return subcmd(SOUNDtab,argc,argv,p);
  45. }
  46.  
  47.  
  48. static int
  49. dosqldatabase(argc,argv,p)
  50. int argc;
  51. char *argv[];
  52. void *p OPTIONAL;
  53. {
  54.     if(argc < 2)    {
  55.         if (SQL_DATABASE)
  56.             tprintf ("%s\n", SQL_DATABASE);
  57.     } else {
  58.         if (SQL_DATABASE)
  59.             free (SQL_DATABASE);
  60.         SQL_DATABASE = strdup (argv[1]);
  61.     }
  62.     return 0;
  63. }
  64.  
  65.  
  66. static int
  67. dosqllimit(argc,argv,p)
  68. int argc;
  69. char *argv[];
  70. void *p OPTIONAL;
  71. {
  72.     return setbool(&SQL_LIMIT,"Limit non-SYSOPs to only 'select' queries",argc,argv);
  73. }
  74.  
  75.  
  76. static int
  77. dosqlhost(argc,argv,p)
  78. int argc;
  79. char *argv[];
  80. void *p OPTIONAL;
  81. {
  82.     if(argc < 2)    {
  83.         if (SQL_HOST)
  84.             tprintf ("%s\n", SQL_HOST);
  85.     } else {
  86.         if (SQL_HOST)
  87.             free (SQL_HOST);
  88.         SQL_HOST = strdup (argv[1]);
  89.     }
  90.     return 0;
  91. }
  92.  
  93.  
  94. static int
  95. dosqlquery(argc,argv,p)
  96. int argc OPTIONAL;
  97. char *argv[];
  98. void *p OPTIONAL;
  99. {
  100.     (void) sql_query (argv[1]);
  101.     return 0;
  102. }
  103.  
  104.  
  105.  
  106. static int
  107. dosqluserquery(argc,argv,p)
  108. int argc OPTIONAL;
  109. char *argv[];
  110. void *p OPTIONAL;
  111. {
  112.     if (SQL_LIMIT && strnicmp (argv[1], "select ", 7))
  113.         tprintf ("Sorry, only SQL 'select' commands are availble to non-SYSOPs\n");
  114.     else
  115.         (void) sql_query (argv[1]);
  116.     return 0;
  117. }
  118.  
  119.  
  120.  
  121. void
  122. sql_init ()
  123. {
  124.     SQL_DATABASE = strdup ("tnos");
  125. }
  126.  
  127.  
  128. /* This opens the sql server, and sets the database to dbname */
  129. int
  130. sql_open (dbname)
  131. char *dbname;
  132. {
  133. int sock;
  134.  
  135.     if ((sock = msqlConnect (SQL_HOST)) != -1)
  136.         if (msqlSelectDB (sock, dbname) != -1)
  137.             return sock;
  138.     return -1;
  139. }
  140.  
  141.  
  142. void
  143. sql_error ()
  144. {
  145.     tprintf ("SQL ERROR: %s\n", msqlErrMsg);
  146. }
  147.  
  148.  
  149. void
  150. sql_close (sock)
  151. int sock;
  152. {
  153.     msqlClose (sock);
  154. }
  155.  
  156.  
  157. void
  158. sql_endquery (result)
  159. m_result *result;
  160. {
  161.     msqlFreeResult(result);
  162. }
  163.  
  164.  
  165. m_result *
  166. sql_run (sock, query)
  167. int sock;
  168. char *query;
  169. {
  170. m_result *result;
  171. int count;
  172. int retries;
  173.  
  174.     for (retries = 0; retries < SQLRETRIES; retries++) {
  175.         if (msqlQuery (sock, query) != -1)
  176.             break;
  177.         (void) mspause (500);
  178.     }
  179.     if (retries == SQLRETRIES)    {
  180.         sql_error ();
  181.         return NULLSQLRESULT;
  182.     }
  183.     tprintf ("\nQuery OK.\n\n");
  184.     result = msqlStoreResult();
  185.     if (result)    {
  186.         count = msqlNumRows(result);
  187.         tprintf("%d row%s matched.\n\n",count, (count != 1) ? "s" : "");
  188.     }
  189.     return (result);
  190. }
  191.  
  192.  
  193. static void
  194. separatorline (result)
  195. m_result *result;
  196. {
  197. m_field    *curField;
  198. int length = 0;
  199. int k;
  200.  
  201.     /* Print a pretty header .... */
  202.     tputs (" +");
  203.  
  204.     /* first calculate size */
  205.     while((curField = msqlFetchField(result)) != ((m_field *)0))    {
  206.         switch(curField->type)    {
  207.                 case REAL_TYPE:
  208.                 length = (int) strlen(curField->name);
  209.                 if (length < 12)
  210.                     length = 12;
  211.                 break;
  212.  
  213.                 case INT_TYPE:
  214.                 length = (int) strlen(curField->name);
  215.                 if (length < 8)
  216.                     length = 8;
  217.                 break;
  218.  
  219.                 case CHAR_TYPE:
  220.                 length = (int)strlen(curField->name);
  221.                 length = max(length, curField->length);
  222.                 break;
  223.  
  224.             default:
  225.                 break;
  226.         }
  227.         for (k = 0; k < length; k++)
  228.             tputc ('-');
  229.         tputs ("-+");
  230.     }
  231.     tputs ("\n");
  232.     msqlFieldSeek(result,0);
  233. }
  234.  
  235. void
  236. sql_printheader (result)
  237. m_result *result;
  238. {
  239. m_field    *curField;
  240. int length = 0;
  241.  
  242.     separatorline (result);
  243.     tprintf(" |");
  244.     while((curField = msqlFetchField(result)) != ((m_field *)0))    {
  245.         switch(curField->type)    {
  246.                 case INT_TYPE:
  247.                 length = (int) strlen(curField->name);
  248.                 if (length < 8)
  249.                     length = 8;
  250.                 break;
  251.  
  252.                 case REAL_TYPE:
  253.                 length = (int) strlen(curField->name);
  254.                 if (length < 12)
  255.                     length = 12;
  256.                 break;
  257.  
  258.                 case CHAR_TYPE:
  259.                 length = (int)strlen(curField->name);
  260.                 length = max(length, curField->length);
  261.                 break;
  262.  
  263.             default:
  264.                 break;
  265.         }
  266.         tprintf(" %-*.*s|", length, length, curField->name);
  267.     }
  268.     tputs("\n");
  269.     msqlFieldSeek(result,0);
  270.     separatorline (result);
  271. }
  272.  
  273.  
  274. void
  275. sql_printresults (result)
  276. m_result *result;
  277. {
  278. m_row cur;
  279. m_field *curField;
  280. int off, length = 0;
  281.  
  282.     /* Print the returned data */
  283.     while ((cur = msqlFetchRow(result)) != ((m_row)0))    {
  284.         off = 0;
  285.         tprintf(" |");
  286.         while(off < msqlNumFields(result))    {
  287.             curField = msqlFetchField(result);
  288.             switch(curField->type)        {
  289.                 case INT_TYPE:
  290.                 length = (int) strlen(curField->name);
  291.                 if (length < 8)
  292.                     length = 8;
  293.                 break;
  294.  
  295.                 case REAL_TYPE:
  296.                 length = (int) strlen(curField->name);
  297.                 if (length < 12)
  298.                     length = 12;
  299.                 break;
  300.  
  301.                 case CHAR_TYPE:
  302.                 length = (int)strlen(curField->name);
  303.                 length = max(length, curField->length);
  304.                 break;
  305.  
  306.                 default:
  307.                     break;
  308.             }
  309.             if (cur[off])
  310.                 tprintf(" %-*.*s|", length, length, cur[off]);
  311.             else
  312.                 tprintf(" %-*.*s|", length, length, "NULL");
  313.             off++;
  314.         }
  315.         tprintf("\n");
  316.         msqlFieldSeek(result,0);
  317.     }
  318.     separatorline (result);
  319.     tputs ("\n");
  320. }
  321.  
  322.  
  323. int
  324. sql_query (query)
  325. char *query;
  326. {
  327. int sock;
  328. m_result *result;
  329. int retries;
  330.  
  331.     for (retries = 0; retries < SQLRETRIES; retries++)    {
  332.         if ((sock = sql_open (SQL_DATABASE)) != -1)
  333.             break;
  334.         (void) mspause (500);
  335.     }
  336.     if (retries == SQLRETRIES)    {
  337.         sql_error ();
  338.         return -1;
  339.     }
  340.     result = sql_run (sock, query);
  341.     if (result != NULLSQLRESULT)    {
  342.         sql_printheader (result);
  343.         sql_printresults (result);
  344.         sql_endquery (result);
  345.     }
  346.     sql_close (sock);
  347.     return 0;
  348. }
  349.  
  350.  
  351.  
  352. #endif /* SQL */
  353.  
  354.